Controlli delle Proprietà in Eccesso di TypeScript: Rafforzare la Sicurezza dei Tipi Oggetto

            
interface User {
  name: string;
  age: number;
}

const newUser: User = {
  name: 'Alice',
  age: 30,
  email: 'alice@example.com' // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'email' non esiste nel tipo 'User'.
};

            

              
                Copy
              
            
          

            
interface Product {
  id: number;
  name: string;
}

function displayProduct(product: Product): void {
  console.log(`Product ID: ${product.id}, Name: ${product.name}`);
}

displayProduct({
  id: 101,
  name: 'Laptop',
  price: 1200 // Errore: L'argomento di tipo '{ id: number; name: string; price: number; }' non è assegnabile al parametro di tipo 'Product'.
             // Il letterale oggetto può specificare solo proprietà conosciute, e 'price' non esiste nel tipo 'Product'.
});

            

              
                Copy
              
            
          

            
interface Config {
  timeout: number;
}

function setupConfig(config: Config) {
  console.log(`Timeout set to: ${config.timeout}`);
}

const userProvidedConfig = {
  timeout: 5000,
  retries: 3 // Questa proprietà 'retries' è una proprietà in eccesso secondo 'Config'
};

setupConfig(userProvidedConfig); // Nessun errore!

// Anche se userProvidedConfig ha una proprietà extra, il controllo viene saltato
// perché non è un letterale oggetto passato direttamente.
// TypeScript controlla il tipo di userProvidedConfig stesso.
// Se userProvidedConfig fosse stato dichiarato con il tipo Config, un errore si sarebbe verificato prima.
// Tuttavia, se dichiarato come 'any' o un tipo più ampio, l'errore viene posticipato.

// Un modo più preciso per mostrare l'aggiramento:
let anotherConfig;

if (Math.random() > 0.5) {
  anotherConfig = {
    timeout: 1000,
    host: 'localhost' // Proprietà in eccesso
  };
} else {
  anotherConfig = {
    timeout: 2000,
    port: 8080 // Proprietà in eccesso
  };
}

setupConfig(anotherConfig as Config); // Nessun errore grazie all'asserzione di tipo e all'aggiramento

// La chiave è che 'anotherConfig' non è un letterale oggetto al momento dell'assegnazione a setupConfig.
// Se avessimo una variabile intermedia tipizzata come 'Config', l'assegnazione iniziale fallirebbe.

// Esempio di variabile intermedia:
let intermediateConfig: Config;

intermediateConfig = {
  timeout: 3000,
  logging: true // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'logging' non esiste nel tipo 'Config'.
};

            

              
                Copy
              
            
          

            
interface Settings {
  theme: 'dark' | 'light';
}

const mySettings = {
  theme: 'dark',
  fontSize: 14 // Proprietà in eccesso
} as Settings;

// Nessun errore qui grazie all'asserzione di tipo.
// Stiamo dicendo a TypeScript: "Fidati, questo oggetto è conforme a Settings."
console.log(mySettings.theme);
// console.log(mySettings.fontSize); // Questo causerebbe un errore a runtime se fontSize non fosse effettivamente presente.

            

              
                Copy
              
            
          

            
interface FlexibleObject {
  id: number;
  [key: string]: any; // Permette qualsiasi chiave stringa con qualsiasi valore
}

const flexibleItem: FlexibleObject = {
  id: 1,
  name: 'Widget',
  version: '1.0.0'
};

// Nessun errore perché 'name' e 'version' sono consentiti dalla firma di indice.
console.log(flexibleItem.name);

            

              
                Copy
              
            
          

            
interface BaseConfig {
  host: string;
}

interface ExtendedConfig extends BaseConfig {
  port: number;
}

const defaultConfig: BaseConfig = {
  host: 'localhost'
};

const userConfig = {
  port: 8080,
  timeout: 5000 // Proprietà in eccesso rispetto a BaseConfig, ma attesa dal tipo unito
};

// Spread in un nuovo letterale oggetto conforme a ExtendedConfig
const finalConfig: ExtendedConfig = {
  ...defaultConfig,
  ...userConfig
};

// Questo è generalmente corretto perché 'finalConfig' è dichiarato come 'ExtendedConfig'
// e le proprietà corrispondono. Il controllo avviene sul tipo di 'finalConfig'.

// Consideriamo uno scenario in cui fallirebbe:

interface SmallConfig {
  key: string;
}

const data1 = { key: 'abc', value: 123 }; // 'value' è extra qui
const data2 = { key: 'xyz', status: 'active' }; // 'status' è extra qui

// Tentativo di assegnare a un tipo che non accetta extra

// const combined: SmallConfig = {
//   ...data1, // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'value' non esiste nel tipo 'SmallConfig'.
//   ...data2  // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'status' non esiste nel tipo 'SmallConfig'.
// };

// L'errore si verifica perché il letterale oggetto formato dalla sintassi spread
// contiene proprietà ('value', 'status') non presenti in 'SmallConfig'.

// Se creiamo una variabile intermedia con un tipo più ampio:

const temp: any = {
  ...data1,
  ...data2
};

// Poi assegnando a SmallConfig, il controllo delle proprietà in eccesso viene aggirato sulla creazione del letterale iniziale,
// ma il controllo del tipo sull'assegnazione potrebbe comunque verificarsi se il tipo di temp viene inferito in modo più restrittivo.
// Tuttavia, se temp è 'any', nessun controllo avviene fino all'assegnazione a 'combined'.

// Affiniamo la comprensione dello spread con i controlli delle proprietà in eccesso:
// Il controllo avviene quando il letterale oggetto creato dalla sintassi spread viene assegnato
// a una variabile o passato a una funzione che si aspetta un tipo più specifico.

interface SpecificShape { 
  id: number;
}

const objA = { id: 1, extra1: 'hello' };
const objB = { id: 2, extra2: 'world' };

// Questo fallirà se SpecificShape non permette 'extra1' o 'extra2':
// const merged: SpecificShape = {
//   ...objA,
//   ...objB
// };

// La ragione del fallimento è che la sintassi spread crea di fatto un nuovo letterale oggetto.
// Se objA e objB avessero chiavi sovrapposte, l'ultima vincerebbe. Il compilatore
// vede questo letterale risultante e lo controlla rispetto a 'SpecificShape'.

// Per farlo funzionare, potresti aver bisogno di un passaggio intermedio o di un tipo più permissivo:

const tempObj = {
  ...objA,
  ...objB
};

// Ora, se tempObj ha proprietà non presenti in SpecificShape, l'assegnazione fallirà:
// const mergedCorrected: SpecificShape = tempObj; // Errore: Il letterale oggetto può specificare solo proprietà conosciute...

// La chiave è che il compilatore analizza la forma del letterale oggetto in formazione.
// Se quel letterale contiene proprietà non definite nel tipo di destinazione, è un errore.

// Il caso d'uso tipico della sintassi spread con i controlli delle proprietà in eccesso:

interface UserProfile {
  userId: string;
  username: string;
}

interface AdminProfile extends UserProfile {
  adminLevel: number;
}

const baseUserData: UserProfile = {
  userId: 'user-123',
  username: 'coder'
};

const adminData = {
  adminLevel: 5,
  lastLogin: '2023-10-27'
};

// È qui che il controllo delle proprietà in eccesso è rilevante:
// const adminProfile: AdminProfile = {
//   ...baseUserData,
//   ...adminData // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'lastLogin' non esiste nel tipo 'AdminProfile'.
// };

// Il letterale oggetto creato dallo spread ha 'lastLogin', che non è in 'AdminProfile'.
// Per risolvere, 'adminData' dovrebbe idealmente conformarsi ad AdminProfile o la proprietà in eccesso dovrebbe essere gestita.

// Approccio corretto:
const validAdminData = {
  adminLevel: 5
};

const adminProfileCorrect: AdminProfile = {
  ...baseUserData,
  ...validAdminData
};

console.log(adminProfileCorrect.userId);
console.log(adminProfileCorrect.adminLevel);

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
}

interface UserWithMetadata extends UserProfile {
  metadata: {
    [key: string]: any;
  };
}

// O più comunemente con un alias di tipo e la sintassi rest:
type UserProfileWithMetadata = UserProfile & {
  [key: string]: any;
};

const user1: UserProfileWithMetadata = {
  id: 1,
  name: 'Bob',
  email: 'bob@example.com',
  isAdmin: true
};

// Nessun errore, poiché 'email' e 'isAdmin' sono catturati dalla firma di indice in UserProfileWithMetadata.
console.log(user1.email);
console.log(user1.isAdmin);

// Un altro modo utilizzando i parametri rest in una definizione di tipo:
interface ConfigWithRest {
  apiUrl: string;
  timeout?: number;
  // Cattura tutte le altre proprietà in 'extraConfig'
  [key: string]: any;
}

const appConfig: ConfigWithRest = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  featureFlags: {
    newUI: true,
    betaFeatures: false
  }
};

console.log(appConfig.featureFlags);

            

              
                Copy
              
            
          

            
interface Employee {
  employeeId: string;
  department: string;
}

function processEmployeeData(data: Employee & { [key: string]: any }) {
  const { employeeId, department, ...otherDetails } = data;

  console.log(`Employee ID: ${employeeId}`);
  console.log(`Department: ${department}`);
  console.log('Other details:', otherDetails);
  // otherDetails conterrà qualsiasi proprietà non esplicitamente destrutturata,
  // come 'salary', 'startDate', ecc.
}

const employeeInfo = {
  employeeId: 'emp-789',
  department: 'Engineering',
  salary: 90000,
  startDate: '2022-01-15'
};

processEmployeeData(employeeInfo);

// Anche se employeeInfo avesse inizialmente una proprietà extra, il controllo delle proprietà in eccesso
// viene aggirato se la firma della funzione lo accetta (ad esempio, usando una firma di indice).
// Se processEmployeeData fosse tipizzato strettamente come 'Employee', e employeeInfo avesse 'salary',
// si verificherebbe un errore SE employeeInfo fosse un letterale oggetto passato direttamente.
// Ma qui, employeeInfo è una variabile, e il tipo della funzione gestisce gli extra.

            

              
                Copy
              
            
          

            
interface UserProfile {
  id: number;
  name: string;
  email?: string; // Email opzionale
}

const userWithEmail: UserProfile = {
  id: 2,
  name: 'Charlie',
  email: 'charlie@example.com'
};

const userWithoutEmail: UserProfile = {
  id: 3,
  name: 'David'
};

// Se proviamo ad aggiungere una proprietà non presente in UserProfile:
// const userWithExtra: UserProfile = {
//   id: 4,
//   name: 'Eve',
//   phoneNumber: '555-1234'
// }; // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'phoneNumber' non esiste nel tipo 'UserProfile'.

            

              
                Copy
              
            
          

            
interface ProductConfig {
  id: string;
  version: string;
}

// Immagina che questo provenga da una fonte esterna o da un modulo meno restrittivo
const externalConfig = {
  id: 'prod-abc',
  version: '1.2',
  debugMode: true // Proprietà in eccesso
};

// Se sai che 'externalConfig' avrà sempre 'id' e 'version' e vuoi trattarlo come ProductConfig:
const productConfig = externalConfig as ProductConfig;

// Questa asserzione aggira il controllo delle proprietà in eccesso su `externalConfig` stesso.
// Tuttavia, se dovessi passare direttamente un letterale oggetto:

// const productConfigLiteral: ProductConfig = {
//   id: 'prod-xyz',
//   version: '2.0',
//   debugMode: false
// }; // Errore: Il letterale oggetto può specificare solo proprietà conosciute, e 'debugMode' non esiste nel tipo 'ProductConfig'.

            

              
                Copy
              
            
          

            
interface Shape {
  kind: 'circle' | 'square';
}

interface Circle extends Shape {
  kind: 'circle';
  radius: number;
}

interface Square extends Shape {
  kind: 'square';
  sideLength: number;
}

function calculateArea(shape: Shape) {
  if (shape.kind === 'circle') {
    // TypeScript sa che 'shape' è un Circle qui
    console.log(Math.PI * shape.radius ** 2);
  } else if (shape.kind === 'square') {
    // TypeScript sa che 'shape' è uno Square qui
    console.log(shape.sideLength ** 2);
  }
}

const circleData = {
  kind: 'circle' as const, // Uso di 'as const' per l'inferenza del tipo letterale
  radius: 10,
  color: 'red' // Proprietà in eccesso
};

// Quando passato a calculateArea, la firma della funzione si aspetta 'Shape'.
// La funzione stessa accederà correttamente a 'kind'.
// Se calculateArea si aspettasse direttamente 'Circle' e ricevesse circleData
// come un letterale oggetto, 'color' sarebbe un problema.

// Illustriamo il controllo delle proprietà in eccesso con una funzione che si aspetta un sottotipo specifico:

function processCircle(circle: Circle) {
  console.log(`Processing circle with radius: ${circle.radius}`);
}

// processCircle(circleData); // Errore: L'argomento di tipo '{ kind: "circle"; radius: number; color: string; }' non è assegnabile al parametro di tipo 'Circle'.
                         // Il letterale oggetto può specificare solo proprietà conosciute, e 'color' non esiste nel tipo 'Circle'.

// Per risolvere, puoi destrutturare o usare un tipo più permissivo per circleData:

const { color, ...circleDataWithoutColor } = circleData;
processCircle(circleDataWithoutColor);

// O definire circleData per includere un tipo più ampio:

const circleDataWithExtras: Circle & { [key: string]: any } = {
  kind: 'circle',
  radius: 15,
  color: 'blue'
};
processCircle(circleDataWithExtras); // Ora funziona.

            

              
                Copy